Типы шаблонных литералов: сопоставление строк с шаблонами и проверка в TypeScript

Система типов TypeScript постоянно развивается, предлагая разработчикам более мощные инструменты для выражения сложной логики и обеспечения безопасности типов. Одной из самых интересных и универсальных функций, представленных в последних версиях, являются типы шаблонных литералов. Эти типы позволяют манипулировать строками на уровне типов, обеспечивая расширенное сопоставление строк с шаблонами и проверку. Это открывает целый новый мир возможностей для создания более надежных и удобных в обслуживании приложений.

Что такое типы шаблонных литералов?

Типы шаблонных литералов - это форма типа, которая строится путем объединения строковых литеральных типов и типов объединения, подобно тому, как шаблонные литералы работают в JavaScript. Однако вместо создания строк во время выполнения они создают новые типы на основе существующих.

Вот основной пример:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // type MyGreeting = "Hello, World!"

            

              
                Copy
              
            
          

В этом примере `Greeting` - это тип шаблонного литерала, который принимает строковый тип `T` в качестве входных данных и возвращает новый тип, который является объединением "Hello, ", `T` и "!".

Базовое сопоставление строк с шаблонами

Типы шаблонных литералов можно использовать для выполнения базового сопоставления строк с шаблонами. Это позволяет создавать типы, которые действительны только в том случае, если они соответствуют определенному шаблону.

Например, вы можете создать тип, который принимает только строки, начинающиеся с "prefix-":

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

В этом примере `PrefixedString` использует условный тип для проверки, начинается ли входная строка `T` с "prefix-". Если это так, то тип - это сам `T`; в противном случае это `never`. `never` - это специальный тип в TypeScript, который представляет тип значений, которые никогда не встречаются, эффективно исключая недопустимую строку.

Извлечение частей строки

Типы шаблонных литералов также можно использовать для извлечения частей строки. Это особенно полезно, когда вам нужно проанализировать данные из строк и преобразовать их в различные типы.

Предположим, у вас есть строка, которая представляет координату в формате "x:10,y:20". Вы можете использовать типы шаблонных литералов для извлечения значений x и y:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

В этом примере `ExtractX` и `ExtractY` используют ключевое слово `infer` для захвата частей строки, которые соответствуют типу `number`. `infer` позволяет извлечь тип из сопоставления с шаблоном. Захваченные типы затем используются в качестве возвращаемого типа условного типа.

Расширенная проверка строк

Типы шаблонных литералов можно комбинировать с другими функциями TypeScript, такими как типы объединения и условные типы, для выполнения расширенной проверки строк. Это позволяет создавать типы, которые обеспечивают соблюдение сложных правил в отношении структуры и содержимого строк.

Например, вы можете создать тип, который проверяет строки даты ISO 8601:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

Здесь `Year`, `Month` и `Day` определены с использованием типов шаблонных литералов для представления допустимых форматов для каждой части даты. Затем `ISODate` объединяет эти типы для создания типа, представляющего допустимую строку даты ISO 8601. В примере также показано, как этот тип можно использовать для обеспечения форматирования данных в функции, предотвращая передачу неправильных форматов даты. Это повышает надежность кода и предотвращает ошибки времени выполнения, вызванные недопустимыми входными данными.

Реальные сценарии использования

Типы шаблонных литералов можно использовать в различных реальных сценариях. Вот несколько примеров:

• Проверка формы: Вы можете использовать типы шаблонных литералов для проверки формата вводимых данных формы, таких как адреса электронной почты, номера телефонов и почтовые индексы.
• Проверка запросов API: Вы можете использовать типы шаблонных литералов для проверки структуры полезных нагрузок запросов API, гарантируя, что они соответствуют ожидаемому формату. Например, проверка кода валюты (например, "USD", "EUR", "GBP").
• Анализ файлов конфигурации: Вы можете использовать типы шаблонных литералов для анализа файлов конфигурации и извлечения значений на основе определенных шаблонов. Рассмотрите возможность проверки путей к файлам в объекте конфигурации.
• Перечисления на основе строк: Вы можете создавать перечисления на основе строк с проверкой с использованием типов шаблонных литералов.

Пример: проверка кодов валют

Давайте рассмотрим более подробный пример проверки кодов валют. Мы хотим убедиться, что в нашем приложении используются только действительные коды валют ISO 4217. Эти коды обычно состоят из трех букв в верхнем регистре.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase}${Uppercase}${Uppercase}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

В этом примере показано, как создать тип `CurrencyCode`, который принимает только строки, состоящие из трех символов в верхнем регистре. Второй, более строго типизированный пример показывает, как еще больше ограничить его предварительно определенным списком приемлемых валют.

Пример: проверка путей конечных точек API

Другой вариант использования - проверка путей конечных точек API. Вы можете определить тип, представляющий допустимую структуру конечной точки API, гарантируя, что запросы отправляются по правильным путям. Это особенно полезно в микросервисных архитектурах, где несколько служб могут предоставлять различные API.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

Это позволяет более точно определить структуру конечных точек API, предотвращая опечатки и обеспечивая согласованность в вашем приложении. Это простой пример; можно создавать более сложные шаблоны для проверки параметров запроса и других частей URL.

Преимущества использования типов шаблонных литералов

Использование типов шаблонных литералов для сопоставления строк с шаблонами и проверки предлагает несколько преимуществ:

• Улучшенная безопасность типов: Типы шаблонных литералов позволяют применять более строгие ограничения типов к строкам, снижая риск ошибок времени выполнения.
• Улучшенная читаемость кода: Типы шаблонных литералов делают ваш код более читаемым, четко выражая ожидаемый формат строк.
• Повышенная удобство обслуживания: Типы шаблонных литералов делают ваш код более удобным в обслуживании, предоставляя единый источник достоверных правил проверки строк.
• Улучшенный опыт разработчика: Типы шаблонных литералов обеспечивают лучшее автозаполнение и сообщения об ошибках, улучшая общий опыт разработчика.

Ограничения

Хотя типы шаблонных литералов и являются мощными, у них также есть некоторые ограничения:

• Сложность: Типы шаблонных литералов могут стать сложными, особенно при работе со сложными шаблонами. Крайне важно сбалансировать преимущества безопасности типов с удобством обслуживания кода.
• Производительность: Типы шаблонных литералов могут влиять на производительность компиляции, особенно в крупных проектах. Это связано с тем, что TypeScript необходимо выполнять более сложную проверку типов.
• Ограниченная поддержка регулярных выражений: Хотя типы шаблонных литералов позволяют сопоставлять с шаблонами, они не поддерживают весь спектр функций регулярных выражений. Для очень сложной проверки строк по-прежнему могут потребоваться регулярные выражения времени выполнения наряду с этими конструкциями типов для правильной очистки входных данных.

Рекомендации

Вот несколько рекомендаций, которые следует помнить при использовании типов шаблонных литералов:

• Начните с простого: Начните с простых шаблонов и постепенно увеличивайте сложность по мере необходимости.
• Используйте описательные имена: Используйте описательные имена для типов шаблонных литералов, чтобы улучшить читаемость кода.
• Документируйте свои типы: Документируйте свои типы шаблонных литералов, чтобы объяснить их назначение и использование.
• Тщательно тестируйте: Тщательно протестируйте свои типы шаблонных литералов, чтобы убедиться, что они ведут себя должным образом.
• Учитывайте производительность: Помните о влиянии типов шаблонных литералов на производительность компиляции и соответствующим образом оптимизируйте свой код.

Заключение

Типы шаблонных литералов - это мощная функция в TypeScript, которая позволяет выполнять расширенные манипуляции со строками, сопоставление с шаблонами и проверку на уровне типов. Используя типы шаблонных литералов, вы можете создавать более надежные, удобные в обслуживании и типобезопасные приложения. Хотя у них есть некоторые ограничения, преимущества использования типов шаблонных литералов часто перевешивают недостатки, что делает их ценным инструментом в арсенале любого разработчика TypeScript. Поскольку язык TypeScript продолжает развиваться, понимание и использование этих расширенных функций типов будет иметь решающее значение для создания высококачественного программного обеспечения. Не забывайте сбалансировать сложность с удобочитаемостью и всегда уделяйте первоочередное внимание тщательному тестированию.